#include "DetourNavMeshQuery.h"
#ifdef __cplusplus
extern "C" {
#endif
dtStatus nav_dtNavMeshQuery_closestPointOnPoly(dtNavMeshQuery const * c_this,dtPolyRef ref,float const * pos,float * closest,bool * posOverPoly){
	dtPolyRef c_arg_ref=ref;
	float const * c_arg_pos=(float const *)(void*)(pos);
	float * c_arg_closest=(float *)(void*)(closest);
	bool * c_arg_posOverPoly=(bool *)(void*)(posOverPoly);
	dtStatus c_out = c_this->closestPointOnPoly(c_arg_ref,c_arg_pos,c_arg_closest,c_arg_posOverPoly);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_closestPointOnPolyBoundary(dtNavMeshQuery const * c_this,dtPolyRef ref,float const * pos,float * closest){
	dtPolyRef c_arg_ref=ref;
	float const * c_arg_pos=(float const *)(void*)(pos);
	float * c_arg_closest=(float *)(void*)(closest);
	dtStatus c_out = c_this->closestPointOnPolyBoundary(c_arg_ref,c_arg_pos,c_arg_closest);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

void nav_dtNavMeshQuery_Delete(dtNavMeshQuery * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtNavMeshQuery_DeleteArray(dtNavMeshQuery * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtNavMeshQuery * nav_NewdtNavMeshQuery(){
	dtNavMeshQuery* wrap_out = new dtNavMeshQuery();
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_finalizeSlicedFindPath(dtNavMeshQuery * c_this,dtPolyRef * path,int * pathCount,int const maxPath){
	dtPolyRef * c_arg_path=(dtPolyRef *)(void*)(path);
	int * c_arg_pathCount=(int *)(void*)(pathCount);
	int const c_arg_maxPath=maxPath;
	dtStatus c_out = c_this->finalizeSlicedFindPath(c_arg_path,c_arg_pathCount,c_arg_maxPath);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_finalizeSlicedFindPathPartial(dtNavMeshQuery * c_this,dtPolyRef const * existing,int const existingSize,dtPolyRef * path,int * pathCount,int const maxPath){
	dtPolyRef const * c_arg_existing=(dtPolyRef const *)(void*)(existing);
	int const c_arg_existingSize=existingSize;
	dtPolyRef * c_arg_path=(dtPolyRef *)(void*)(path);
	int * c_arg_pathCount=(int *)(void*)(pathCount);
	int const c_arg_maxPath=maxPath;
	dtStatus c_out = c_this->finalizeSlicedFindPathPartial(c_arg_existing,c_arg_existingSize,c_arg_path,c_arg_pathCount,c_arg_maxPath);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findDistanceToWall(dtNavMeshQuery const * c_this,dtPolyRef startRef,float const * centerPos,float const maxRadius,dtQueryFilter const * filter,float * hitDist,float * hitPos,float * hitNormal){
	dtPolyRef c_arg_startRef=startRef;
	float const * c_arg_centerPos=(float const *)(void*)(centerPos);
	float const c_arg_maxRadius=maxRadius;
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	float * c_arg_hitDist=(float *)(void*)(hitDist);
	float * c_arg_hitPos=(float *)(void*)(hitPos);
	float * c_arg_hitNormal=(float *)(void*)(hitNormal);
	dtStatus c_out = c_this->findDistanceToWall(c_arg_startRef,c_arg_centerPos,c_arg_maxRadius,c_arg_filter,c_arg_hitDist,c_arg_hitPos,c_arg_hitNormal);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findLocalNeighbourhood(dtNavMeshQuery const * c_this,dtPolyRef startRef,float const * centerPos,float const radius,dtQueryFilter const * filter,dtPolyRef * resultRef,dtPolyRef * resultParent,int * resultCount,int const maxResult){
	dtPolyRef c_arg_startRef=startRef;
	float const * c_arg_centerPos=(float const *)(void*)(centerPos);
	float const c_arg_radius=radius;
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyRef * c_arg_resultRef=(dtPolyRef *)(void*)(resultRef);
	dtPolyRef * c_arg_resultParent=(dtPolyRef *)(void*)(resultParent);
	int * c_arg_resultCount=(int *)(void*)(resultCount);
	int const c_arg_maxResult=maxResult;
	dtStatus c_out = c_this->findLocalNeighbourhood(c_arg_startRef,c_arg_centerPos,c_arg_radius,c_arg_filter,c_arg_resultRef,c_arg_resultParent,c_arg_resultCount,c_arg_maxResult);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findNearestPoly(dtNavMeshQuery const * c_this,float const * center,float const * halfExtents,dtQueryFilter const * filter,dtPolyRef * nearestRef,float * nearestPt){
	float const * c_arg_center=(float const *)(void*)(center);
	float const * c_arg_halfExtents=(float const *)(void*)(halfExtents);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyRef * c_arg_nearestRef=(dtPolyRef *)(void*)(nearestRef);
	float * c_arg_nearestPt=(float *)(void*)(nearestPt);
	dtStatus c_out = c_this->findNearestPoly(c_arg_center,c_arg_halfExtents,c_arg_filter,c_arg_nearestRef,c_arg_nearestPt);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findNearestPoly11(dtNavMeshQuery const * c_this,float const * center,float const * halfExtents,dtQueryFilter const * filter,dtPolyRef * nearestRef,float * nearestPt,bool * isOverPoly){
	float const * c_arg_center=(float const *)(void*)(center);
	float const * c_arg_halfExtents=(float const *)(void*)(halfExtents);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyRef * c_arg_nearestRef=(dtPolyRef *)(void*)(nearestRef);
	float * c_arg_nearestPt=(float *)(void*)(nearestPt);
	bool * c_arg_isOverPoly=(bool *)(void*)(isOverPoly);
	dtStatus c_out = c_this->findNearestPoly(c_arg_center,c_arg_halfExtents,c_arg_filter,c_arg_nearestRef,c_arg_nearestPt,c_arg_isOverPoly);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findPath(dtNavMeshQuery const * c_this,dtPolyRef startRef,dtPolyRef endRef,float const * startPos,float const * endPos,dtQueryFilter const * filter,dtPolyRef * path,int * pathCount,int const maxPath){
	dtPolyRef c_arg_startRef=startRef;
	dtPolyRef c_arg_endRef=endRef;
	float const * c_arg_startPos=(float const *)(void*)(startPos);
	float const * c_arg_endPos=(float const *)(void*)(endPos);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyRef * c_arg_path=(dtPolyRef *)(void*)(path);
	int * c_arg_pathCount=(int *)(void*)(pathCount);
	int const c_arg_maxPath=maxPath;
	dtStatus c_out = c_this->findPath(c_arg_startRef,c_arg_endRef,c_arg_startPos,c_arg_endPos,c_arg_filter,c_arg_path,c_arg_pathCount,c_arg_maxPath);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findPolysAroundCircle(dtNavMeshQuery const * c_this,dtPolyRef startRef,float const * centerPos,float const radius,dtQueryFilter const * filter,dtPolyRef * resultRef,dtPolyRef * resultParent,float * resultCost,int * resultCount,int const maxResult){
	dtPolyRef c_arg_startRef=startRef;
	float const * c_arg_centerPos=(float const *)(void*)(centerPos);
	float const c_arg_radius=radius;
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyRef * c_arg_resultRef=(dtPolyRef *)(void*)(resultRef);
	dtPolyRef * c_arg_resultParent=(dtPolyRef *)(void*)(resultParent);
	float * c_arg_resultCost=(float *)(void*)(resultCost);
	int * c_arg_resultCount=(int *)(void*)(resultCount);
	int const c_arg_maxResult=maxResult;
	dtStatus c_out = c_this->findPolysAroundCircle(c_arg_startRef,c_arg_centerPos,c_arg_radius,c_arg_filter,c_arg_resultRef,c_arg_resultParent,c_arg_resultCost,c_arg_resultCount,c_arg_maxResult);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findPolysAroundShape(dtNavMeshQuery const * c_this,dtPolyRef startRef,float const * verts,int const nverts,dtQueryFilter const * filter,dtPolyRef * resultRef,dtPolyRef * resultParent,float * resultCost,int * resultCount,int const maxResult){
	dtPolyRef c_arg_startRef=startRef;
	float const * c_arg_verts=(float const *)(void*)(verts);
	int const c_arg_nverts=nverts;
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyRef * c_arg_resultRef=(dtPolyRef *)(void*)(resultRef);
	dtPolyRef * c_arg_resultParent=(dtPolyRef *)(void*)(resultParent);
	float * c_arg_resultCost=(float *)(void*)(resultCost);
	int * c_arg_resultCount=(int *)(void*)(resultCount);
	int const c_arg_maxResult=maxResult;
	dtStatus c_out = c_this->findPolysAroundShape(c_arg_startRef,c_arg_verts,c_arg_nverts,c_arg_filter,c_arg_resultRef,c_arg_resultParent,c_arg_resultCost,c_arg_resultCount,c_arg_maxResult);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_findStraightPath(dtNavMeshQuery const * c_this,float const * startPos,float const * endPos,dtPolyRef const * path,int const pathSize,float * straightPath,unsigned char * straightPathFlags,dtPolyRef * straightPathRefs,int * straightPathCount,int const maxStraightPath,int const options){
	float const * c_arg_startPos=(float const *)(void*)(startPos);
	float const * c_arg_endPos=(float const *)(void*)(endPos);
	dtPolyRef const * c_arg_path=(dtPolyRef const *)(void*)(path);
	int const c_arg_pathSize=pathSize;
	float * c_arg_straightPath=(float *)(void*)(straightPath);
	unsigned char * c_arg_straightPathFlags=(unsigned char *)(void*)(straightPathFlags);
	dtPolyRef * c_arg_straightPathRefs=(dtPolyRef *)(void*)(straightPathRefs);
	int * c_arg_straightPathCount=(int *)(void*)(straightPathCount);
	int const c_arg_maxStraightPath=maxStraightPath;
	int const c_arg_options=options;
	dtStatus c_out = c_this->findStraightPath(c_arg_startPos,c_arg_endPos,c_arg_path,c_arg_pathSize,c_arg_straightPath,c_arg_straightPathFlags,c_arg_straightPathRefs,c_arg_straightPathCount,c_arg_maxStraightPath,c_arg_options);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtNavMesh const * nav_dtNavMeshQuery_getAttachedNavMesh(dtNavMeshQuery const * c_this){
	dtNavMesh const * c_out = c_this->getAttachedNavMesh();
	dtNavMesh const * wrap_out  = (dtNavMesh const *)(void*)(c_out);
	return wrap_out;
}

dtNodePool * nav_dtNavMeshQuery_getNodePool(dtNavMeshQuery const * c_this){
	dtNodePool * c_out = c_this->getNodePool();
	dtNodePool * wrap_out  = (dtNodePool *)(void*)(c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_getPathFromDijkstraSearch(dtNavMeshQuery const * c_this,dtPolyRef endRef,dtPolyRef * path,int * pathCount,int maxPath){
	dtPolyRef c_arg_endRef=endRef;
	dtPolyRef * c_arg_path=(dtPolyRef *)(void*)(path);
	int * c_arg_pathCount=(int *)(void*)(pathCount);
	int c_arg_maxPath=maxPath;
	dtStatus c_out = c_this->getPathFromDijkstraSearch(c_arg_endRef,c_arg_path,c_arg_pathCount,c_arg_maxPath);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_getPolyHeight(dtNavMeshQuery const * c_this,dtPolyRef ref,float const * pos,float * height){
	dtPolyRef c_arg_ref=ref;
	float const * c_arg_pos=(float const *)(void*)(pos);
	float * c_arg_height=(float *)(void*)(height);
	dtStatus c_out = c_this->getPolyHeight(c_arg_ref,c_arg_pos,c_arg_height);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_getPolyWallSegments(dtNavMeshQuery const * c_this,dtPolyRef ref,dtQueryFilter const * filter,float * segmentVerts,dtPolyRef * segmentRefs,int * segmentCount,int const maxSegments){
	dtPolyRef c_arg_ref=ref;
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	float * c_arg_segmentVerts=(float *)(void*)(segmentVerts);
	dtPolyRef * c_arg_segmentRefs=(dtPolyRef *)(void*)(segmentRefs);
	int * c_arg_segmentCount=(int *)(void*)(segmentCount);
	int const c_arg_maxSegments=maxSegments;
	dtStatus c_out = c_this->getPolyWallSegments(c_arg_ref,c_arg_filter,c_arg_segmentVerts,c_arg_segmentRefs,c_arg_segmentCount,c_arg_maxSegments);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtNavMeshQuery * nav_dtNavMeshQuery_IndexArray(dtNavMeshQuery * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

dtStatus nav_dtNavMeshQuery_init(dtNavMeshQuery * c_this,dtNavMesh const * tmp_arg_nav,int const maxNodes){
	dtNavMesh const * c_arg_tmp_arg_nav=(dtNavMesh const *)(void*)(tmp_arg_nav);
	int const c_arg_maxNodes=maxNodes;
	dtStatus c_out = c_this->init(c_arg_tmp_arg_nav,c_arg_maxNodes);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_initSlicedFindPath(dtNavMeshQuery * c_this,dtPolyRef startRef,dtPolyRef endRef,float const * startPos,float const * endPos,dtQueryFilter const * filter,unsigned int const options){
	dtPolyRef c_arg_startRef=startRef;
	dtPolyRef c_arg_endRef=endRef;
	float const * c_arg_startPos=(float const *)(void*)(startPos);
	float const * c_arg_endPos=(float const *)(void*)(endPos);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	unsigned int const c_arg_options=options;
	dtStatus c_out = c_this->initSlicedFindPath(c_arg_startRef,c_arg_endRef,c_arg_startPos,c_arg_endPos,c_arg_filter,c_arg_options);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

bool nav_dtNavMeshQuery_isInClosedList(dtNavMeshQuery const * c_this,dtPolyRef ref){
	dtPolyRef c_arg_ref=ref;
	bool c_out = c_this->isInClosedList(c_arg_ref);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_dtNavMeshQuery_isValidPolyRef(dtNavMeshQuery const * c_this,dtPolyRef ref,dtQueryFilter const * filter){
	dtPolyRef c_arg_ref=ref;
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	bool c_out = c_this->isValidPolyRef(c_arg_ref,c_arg_filter);
	bool wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_moveAlongSurface(dtNavMeshQuery const * c_this,dtPolyRef startRef,float const * startPos,float const * endPos,dtQueryFilter const * filter,float * resultPos,dtPolyRef * visited,int * visitedCount,int const maxVisitedSize){
	dtPolyRef c_arg_startRef=startRef;
	float const * c_arg_startPos=(float const *)(void*)(startPos);
	float const * c_arg_endPos=(float const *)(void*)(endPos);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	float * c_arg_resultPos=(float *)(void*)(resultPos);
	dtPolyRef * c_arg_visited=(dtPolyRef *)(void*)(visited);
	int * c_arg_visitedCount=(int *)(void*)(visitedCount);
	int const c_arg_maxVisitedSize=maxVisitedSize;
	dtStatus c_out = c_this->moveAlongSurface(c_arg_startRef,c_arg_startPos,c_arg_endPos,c_arg_filter,c_arg_resultPos,c_arg_visited,c_arg_visitedCount,c_arg_maxVisitedSize);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_queryPolygons(dtNavMeshQuery const * c_this,float const * center,float const * halfExtents,dtQueryFilter const * filter,dtPolyRef * polys,int * polyCount,int const maxPolys){
	float const * c_arg_center=(float const *)(void*)(center);
	float const * c_arg_halfExtents=(float const *)(void*)(halfExtents);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyRef * c_arg_polys=(dtPolyRef *)(void*)(polys);
	int * c_arg_polyCount=(int *)(void*)(polyCount);
	int const c_arg_maxPolys=maxPolys;
	dtStatus c_out = c_this->queryPolygons(c_arg_center,c_arg_halfExtents,c_arg_filter,c_arg_polys,c_arg_polyCount,c_arg_maxPolys);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_queryPolygons11(dtNavMeshQuery const * c_this,float const * center,float const * halfExtents,dtQueryFilter const * filter,dtPolyQuery * query){
	float const * c_arg_center=(float const *)(void*)(center);
	float const * c_arg_halfExtents=(float const *)(void*)(halfExtents);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	dtPolyQuery * c_arg_query=(dtPolyQuery *)(void*)(query);
	dtStatus c_out = c_this->queryPolygons(c_arg_center,c_arg_halfExtents,c_arg_filter,c_arg_query);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_raycast(dtNavMeshQuery const * c_this,dtPolyRef startRef,float const * startPos,float const * endPos,dtQueryFilter const * filter,float * t,float * hitNormal,dtPolyRef * path,int * pathCount,int const maxPath){
	dtPolyRef c_arg_startRef=startRef;
	float const * c_arg_startPos=(float const *)(void*)(startPos);
	float const * c_arg_endPos=(float const *)(void*)(endPos);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	float * c_arg_t=(float *)(void*)(t);
	float * c_arg_hitNormal=(float *)(void*)(hitNormal);
	dtPolyRef * c_arg_path=(dtPolyRef *)(void*)(path);
	int * c_arg_pathCount=(int *)(void*)(pathCount);
	int const c_arg_maxPath=maxPath;
	dtStatus c_out = c_this->raycast(c_arg_startRef,c_arg_startPos,c_arg_endPos,c_arg_filter,c_arg_t,c_arg_hitNormal,c_arg_path,c_arg_pathCount,c_arg_maxPath);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_raycast11(dtNavMeshQuery const * c_this,dtPolyRef startRef,float const * startPos,float const * endPos,dtQueryFilter const * filter,unsigned int const options,dtRaycastHit * hit,dtPolyRef prevRef){
	dtPolyRef c_arg_startRef=startRef;
	float const * c_arg_startPos=(float const *)(void*)(startPos);
	float const * c_arg_endPos=(float const *)(void*)(endPos);
	dtQueryFilter const * c_arg_filter=(dtQueryFilter const *)(void*)(filter);
	unsigned int const c_arg_options=options;
	dtRaycastHit * c_arg_hit=(dtRaycastHit *)(void*)(hit);
	dtPolyRef c_arg_prevRef=prevRef;
	dtStatus c_out = c_this->raycast(c_arg_startRef,c_arg_startPos,c_arg_endPos,c_arg_filter,c_arg_options,c_arg_hit,c_arg_prevRef);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

dtStatus nav_dtNavMeshQuery_updateSlicedFindPath(dtNavMeshQuery * c_this,int const maxIter,int * doneIters){
	int const c_arg_maxIter=maxIter;
	int * c_arg_doneIters=(int *)(void*)(doneIters);
	dtStatus c_out = c_this->updateSlicedFindPath(c_arg_maxIter,c_arg_doneIters);
	dtStatus wrap_out  = (c_out);
	return wrap_out;
}

void nav_dtPolyQuery_Delete(dtPolyQuery * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtPolyQuery_process(dtPolyQuery * c_this,dtMeshTile const * tile,dtPoly * * polys,dtPolyRef * refs,int count){
	dtMeshTile const * c_arg_tile=(dtMeshTile const *)(void*)(tile);
	dtPoly * * c_arg_polys=(dtPoly * *)(void*)(polys);
	dtPolyRef * c_arg_refs=(dtPolyRef *)(void*)(refs);
	int c_arg_count=count;
	c_this->process(c_arg_tile,c_arg_polys,c_arg_refs,c_arg_count);
}

void nav_dtQueryFilter_Delete(dtQueryFilter * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtQueryFilter_DeleteArray(dtQueryFilter * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtQueryFilter * nav_NewdtQueryFilter(){
	dtQueryFilter* wrap_out = new dtQueryFilter();
	return wrap_out;
}

float nav_dtQueryFilter_getAreaCost(dtQueryFilter const * c_this,int const i){
	int const c_arg_i=i;
	float c_out = c_this->getAreaCost(c_arg_i);
	float wrap_out  = (c_out);
	return wrap_out;
}

float nav_dtQueryFilter_getCost(dtQueryFilter const * c_this,float const * pa,float const * pb,dtPolyRef const prevRef,dtMeshTile const * prevTile,dtPoly const * prevPoly,dtPolyRef const curRef,dtMeshTile const * curTile,dtPoly const * curPoly,dtPolyRef const nextRef,dtMeshTile const * nextTile,dtPoly const * nextPoly){
	float const * c_arg_pa=(float const *)(void*)(pa);
	float const * c_arg_pb=(float const *)(void*)(pb);
	dtPolyRef const c_arg_prevRef=prevRef;
	dtMeshTile const * c_arg_prevTile=(dtMeshTile const *)(void*)(prevTile);
	dtPoly const * c_arg_prevPoly=(dtPoly const *)(void*)(prevPoly);
	dtPolyRef const c_arg_curRef=curRef;
	dtMeshTile const * c_arg_curTile=(dtMeshTile const *)(void*)(curTile);
	dtPoly const * c_arg_curPoly=(dtPoly const *)(void*)(curPoly);
	dtPolyRef const c_arg_nextRef=nextRef;
	dtMeshTile const * c_arg_nextTile=(dtMeshTile const *)(void*)(nextTile);
	dtPoly const * c_arg_nextPoly=(dtPoly const *)(void*)(nextPoly);
	float c_out = c_this->getCost(c_arg_pa,c_arg_pb,c_arg_prevRef,c_arg_prevTile,c_arg_prevPoly,c_arg_curRef,c_arg_curTile,c_arg_curPoly,c_arg_nextRef,c_arg_nextTile,c_arg_nextPoly);
	float wrap_out  = (c_out);
	return wrap_out;
}

unsigned short nav_dtQueryFilter_getExcludeFlags(dtQueryFilter const * c_this){
	unsigned short c_out = c_this->getExcludeFlags();
	unsigned short wrap_out  = (c_out);
	return wrap_out;
}

unsigned short nav_dtQueryFilter_getIncludeFlags(dtQueryFilter const * c_this){
	unsigned short c_out = c_this->getIncludeFlags();
	unsigned short wrap_out  = (c_out);
	return wrap_out;
}

dtQueryFilter * nav_dtQueryFilter_IndexArray(dtQueryFilter * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

bool nav_dtQueryFilter_passFilter(dtQueryFilter const * c_this,dtPolyRef const ref,dtMeshTile const * tile,dtPoly const * poly){
	dtPolyRef const c_arg_ref=ref;
	dtMeshTile const * c_arg_tile=(dtMeshTile const *)(void*)(tile);
	dtPoly const * c_arg_poly=(dtPoly const *)(void*)(poly);
	bool c_out = c_this->passFilter(c_arg_ref,c_arg_tile,c_arg_poly);
	bool wrap_out  = (c_out);
	return wrap_out;
}

void nav_dtQueryFilter_setAreaCost(dtQueryFilter * c_this,int const i,float const cost){
	int const c_arg_i=i;
	float const c_arg_cost=cost;
	c_this->setAreaCost(c_arg_i,c_arg_cost);
}

void nav_dtQueryFilter_setExcludeFlags(dtQueryFilter * c_this,unsigned short const flags){
	unsigned short const c_arg_flags=flags;
	c_this->setExcludeFlags(c_arg_flags);
}

void nav_dtQueryFilter_setIncludeFlags(dtQueryFilter * c_this,unsigned short const flags){
	unsigned short const c_arg_flags=flags;
	c_this->setIncludeFlags(c_arg_flags);
}

void nav_dtRaycastHit_Delete(dtRaycastHit * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_dtRaycastHit_DeleteArray(dtRaycastHit * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

dtRaycastHit * nav_NewdtRaycastHit(){
	dtRaycastHit* wrap_out = new dtRaycastHit();
	return wrap_out;
}

int * nav_dtRaycastHit_GetPtrToHitEdgeIndex(dtRaycastHit * c_this){
	return (int *)(&(c_this->hitEdgeIndex));
}

float(*nav_dtRaycastHit_GetPtrToHitNormal(dtRaycastHit * c_this))[3]{
	return (float(*)[3])(&(c_this->hitNormal));
}

int * nav_dtRaycastHit_GetPtrToMaxPath(dtRaycastHit * c_this){
	return (int *)(&(c_this->maxPath));
}

dtPolyRef * * nav_dtRaycastHit_GetPtrToPath(dtRaycastHit * c_this){
	return (dtPolyRef * *)(&(c_this->path));
}

float * nav_dtRaycastHit_GetPtrToPathCost(dtRaycastHit * c_this){
	return (float *)(&(c_this->pathCost));
}

int * nav_dtRaycastHit_GetPtrToPathCount(dtRaycastHit * c_this){
	return (int *)(&(c_this->pathCount));
}

float * nav_dtRaycastHit_GetPtrToT(dtRaycastHit * c_this){
	return (float *)(&(c_this->t));
}

dtRaycastHit * nav_dtRaycastHit_IndexArray(dtRaycastHit * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

dtNavMeshQuery * nav_dtAllocNavMeshQuery(){
	dtNavMeshQuery * c_out = dtAllocNavMeshQuery();
	dtNavMeshQuery * wrap_out  = (dtNavMeshQuery *)(void*)(c_out);
	return wrap_out;
}

void nav_dtFreeNavMeshQuery(dtNavMeshQuery * query){
	dtNavMeshQuery * c_arg_query=(dtNavMeshQuery *)(void*)(query);
	dtFreeNavMeshQuery(c_arg_query);
}

dtNavMeshQuery * nav_NewDtNavMeshQueryPtrArray(long n){
	dtNavMeshQuery* c_this=new dtNavMeshQuery[n];
	return c_this;
}

dtQueryFilter * nav_NewDtQueryFilterPtrArray(long n){
	dtQueryFilter* c_this=new dtQueryFilter[n];
	return c_this;
}

dtRaycastHit * nav_NewDtRaycastHitPtrArray(long n){
	dtRaycastHit* c_this=new dtRaycastHit[n];
	return c_this;
}

#ifdef __cplusplus
}
#endif
